home *** CD-ROM | disk | FTP | other *** search
/ Mac-Source 1994 July / Mac-Source_July_1994.iso / C and C++ / System / cdcl Folder / cdcl.c next >
Encoding:
Text File  |  1986-04-19  |  7.1 KB  |  721 lines  |  [TEXT/MACA]
  1. /*
  2.  
  3.  *    C Declare -- a desk accessory written in Aztec C
  4.  
  5.  *
  6.  
  7.  *    This DA assists you in declaring C variables and functions.
  8.  
  9.  *
  10.  
  11.  *    Written by Michael P. Hecht, 10jan86
  12.  
  13.  */
  14.  
  15. #asm
  16.  
  17. main
  18.  
  19.     dc.w    $0400            ;ctl-enable
  20.  
  21.     dc.w    0            ;no update
  22.  
  23.     dc.w    $014a            ;detect mouse and key down events
  24.  
  25.     dc.w    0            ;menu ID number (none)
  26.  
  27.      
  28.  
  29.     dc.w    open_-main        ;open routine
  30.  
  31.     dc.w    nop_-main        ;prime routine
  32.  
  33.     dc.w    control_-main        ;control routine
  34.  
  35.     dc.w    nop_-main        ;status routine
  36.  
  37.     dc.w    close_-main        ;close routine
  38.  
  39.      
  40.  
  41. title_
  42.  
  43.     dc.b    9
  44.  
  45.     dc.b    "C Declare"
  46.  
  47.     ds        0                ;for alignment
  48.  
  49.      
  50.  
  51.     public    _Uend_,_Dorg_,_Cend_
  52.  
  53.      
  54.  
  55. save_
  56.  
  57.     lea        main+(_Uend_-_Dorg_)+(_Cend_-main),a4        ;set up globals
  58.  
  59.     move.l    a0,Pbp_                                        ;save pb pointer
  60.  
  61.     move.l    a1,Dp_                                        ;save DCE pointer
  62.  
  63.     rts
  64.  
  65.      
  66.  
  67. restore_
  68.  
  69.     move.l    Pbp_,a0
  70.  
  71.     rts
  72.  
  73. #endasm
  74.  
  75.      
  76.  
  77. #define    _DRIVER
  78.  
  79. #include <quickdraw.h>
  80.  
  81. #include <event.h>
  82.  
  83. #include <window.h>
  84.  
  85. #include <control.h>
  86.  
  87. #include <textedit.h>
  88.  
  89. #include <dialog.h>
  90.  
  91. #include <desk.h>
  92.  
  93. #include <scrap.h>
  94.  
  95. #include <toolutil.h>
  96.  
  97. #include <memory.h>
  98.  
  99. #include <pb.h>
  100.  
  101. #include <osutil.h>
  102.  
  103.      
  104.  
  105. #define    SP        (*(struct storage **)Dp->dCtlStorage)
  106.  
  107.      
  108.  
  109. /* Dialog item numbers */
  110.  
  111. #define FUNC_RET    1
  112.  
  113. #define ARRAY_OF    2
  114.  
  115. #define PTR_TO        3
  116.  
  117. #define TEXT        4
  118.  
  119.      
  120.  
  121. /* Owned resource id equates */
  122.  
  123. #define OWNED        0xc000
  124.  
  125. #define BY_DRVR        0x0000
  126.  
  127. #define BY_WDEF        0x0800
  128.  
  129. #define BY_MDEF        0x1000
  130.  
  131. #define BY_CDEF        0x1800
  132.  
  133. #define BY_PDEF        0x2000
  134.  
  135. #define BY_PACK        0x2800
  136.  
  137. #define BY_ID_SHIFT    5
  138.  
  139.      
  140.  
  141. DCEPtr Dp;
  142.  
  143. ParmBlkPtr Pbp;
  144.  
  145.      
  146.  
  147. /* Private storage */
  148.  
  149. struct storage :
  150.  
  151.     int            first;
  152.  
  153.     ControlHandle        func_button;
  154.  
  155.     ControlHandle        array_button;
  156.  
  157.     Handle            text;
  158.  
  159.     StringHandle        init;
  160.  
  161. :;
  162.  
  163.      
  164.  
  165. open()
  166.  
  167. :
  168.  
  169.     register struct DCE        *dp;
  170.  
  171.     register struct storage        *sp;
  172.  
  173.     register WindowPtr        wp;
  174.  
  175.     register StringHandle        s;
  176.  
  177.     register int            dlog_id;
  178.  
  179.     int                junk;
  180.  
  181.     Rect                box;
  182.  
  183.      
  184.  
  185.      
  186.  
  187.     save();
  188.  
  189.     dp = Dp;
  190.  
  191.     wp = dp->dCtlWindow;
  192.  
  193.      
  194.  
  195.     /* First open?  Allocate private storage if so. */
  196.  
  197.     if( !wp ) :
  198.  
  199.         dp->dCtlStorage = NewHandle(( long )sizeof( struct storage ));
  200.  
  201.     :
  202.  
  203.      
  204.  
  205.     /* Lock it down and dereference it */
  206.  
  207.     HLock( dp->dCtlStorage );
  208.  
  209.     sp = SP;
  210.  
  211.      
  212.  
  213.     /* First open?  Allocate DLOG and init other stuff if so. */
  214.  
  215.     if( !wp ) :
  216.  
  217.         /* Compute resource id of DLOG at runtime */
  218.  
  219.         dlog_id = -( dp->dCtlRefNum + 1 );
  220.  
  221.         dlog_id <<= BY_ID_SHIFT;
  222.  
  223.         dlog_id |= OWNED | BY_DRVR | 0;
  224.  
  225.      
  226.  
  227.         /* Bring up the window */
  228.  
  229.         dp->dCtlWindow = wp = GetNewDialog( dlog_id, 0L, -1L );
  230.  
  231.      
  232.  
  233.         /* Grab control handles for the buttons we want to hilite */
  234.  
  235.         GetDItem( wp, FUNC_RET, &junk, &sp->func_button,  &box );
  236.  
  237.         GetDItem( wp, ARRAY_OF, &junk, &sp->array_button, &box );
  238.  
  239.      
  240.  
  241.         /* Grab TE handle so we can modify the text quickly */
  242.  
  243.         GetDItem( wp, TEXT,     &junk, &sp->text,         &box );
  244.  
  245.      
  246.  
  247.         /* Grab the initial text in a resizable handle */
  248.  
  249.         s = NewHandle(( long )sizeof( Str255 ));
  250.  
  251.         HLock( s );
  252.  
  253.         GetIText( sp->text, *s );
  254.  
  255.         HUnlock( s );
  256.  
  257.         SetHandleSize( s, ( long )(( *s )->length + 1 ));
  258.  
  259.         sp->init = s;
  260.  
  261.         sp->first = TRUE;
  262.  
  263.      
  264.  
  265.     :
  266.  
  267.     /* Otherwise, reset if reopened from the front, reset */
  268.  
  269.     else if( wp == FrontWindow()) :
  270.  
  271.         (( WindowPeek )wp )->windowKind = dialogKind;
  272.  
  273.      
  274.  
  275.         HiliteControl( sp->func_button,  0 );
  276.  
  277.         HiliteControl( sp->array_button, 0 );
  278.  
  279.      
  280.  
  281.         s = sp->init;
  282.  
  283.         HLock( s );
  284.  
  285.         SetIText( sp->text, *s );
  286.  
  287.         HUnlock( s );
  288.  
  289.      
  290.  
  291.         sp->first = TRUE;
  292.  
  293.     :
  294.  
  295.      
  296.  
  297.     (( WindowPeek )wp )->windowKind = dp->dCtlRefNum;
  298.  
  299.     HUnlock( dp->dCtlStorage );
  300.  
  301.     restore();
  302.  
  303.     return 0;
  304.  
  305. :
  306.  
  307.      
  308.  
  309. close()
  310.  
  311. :
  312.  
  313.     register struct DCE *dp;
  314.  
  315.     register WindowPtr wp;
  316.  
  317.      
  318.  
  319.      
  320.  
  321.     save();
  322.  
  323.     dp = Dp;
  324.  
  325.      
  326.  
  327.     wp = dp->dCtlWindow;
  328.  
  329.     (( WindowPeek )wp )->windowKind = dialogKind;
  330.  
  331.     DisposDialog( wp );
  332.  
  333.     dp->dCtlWindow = 0;
  334.  
  335.      
  336.  
  337.     DisposHandle( SP->init );
  338.  
  339.     DisposHandle( dp->dCtlStorage );
  340.  
  341.      
  342.  
  343.     restore();
  344.  
  345.     return 0;
  346.  
  347. :
  348.  
  349.      
  350.  
  351. nop()
  352.  
  353. :
  354.  
  355.     return 0;
  356.  
  357. :
  358.  
  359.      
  360.  
  361. control()
  362.  
  363. :
  364.  
  365.     register struct DCE        *dp;
  366.  
  367.     register struct storage        *sp;
  368.  
  369.     register WindowPtr        wp;
  370.  
  371.     register int            what;
  372.  
  373.     EventRecord            fakenull;
  374.  
  375.      
  376.  
  377.      
  378.  
  379.     save();
  380.  
  381.     dp = Dp;
  382.  
  383.     HLock( dp->dCtlStorage );
  384.  
  385.     sp = SP;
  386.  
  387.      
  388.  
  389.     wp = dp->dCtlWindow;
  390.  
  391.     /* Change windowKind so the dialog mgr will recognize it */
  392.  
  393.     (( WindowPeek )wp )->windowKind = dialogKind;
  394.  
  395.      
  396.  
  397.     what = Pbp->u.cp.csCode;
  398.  
  399.      
  400.  
  401.     switch( what ) :
  402.  
  403.      
  404.  
  405.         case accEvent:
  406.  
  407.             event( sp, *( EventRecord ** )&Pbp->u.cp.csParam,
  408.  
  409.                 wp );
  410.  
  411.             break;
  412.  
  413.      
  414.  
  415.         case accCursor:
  416.  
  417.             /* This blinks the caret */
  418.  
  419.             fakenull.what = nullEvent;
  420.  
  421.             DialogSelect( &fakenull, 0L, 0L );
  422.  
  423.             break;
  424.  
  425.      
  426.  
  427.         default:
  428.  
  429.             /* Assume it's an edit something */
  430.  
  431.             edit( what, sp, wp );
  432.  
  433.             break;
  434.  
  435.     :
  436.  
  437.      
  438.  
  439.     HUnlock( dp->dCtlStorage );
  440.  
  441.     (( WindowPeek )wp )->windowKind = dp->dCtlRefNum;
  442.  
  443.      
  444.  
  445.     restore();
  446.  
  447.     return 0;
  448.  
  449. :
  450.  
  451.      
  452.  
  453. event( sp, ep, wp )
  454.  
  455. register struct storage *sp;
  456.  
  457. register EventRecord *ep;
  458.  
  459. WindowPtr wp;
  460.  
  461. :
  462.  
  463.     register StringHandle    s;
  464.  
  465.     register int        eventcode;
  466.  
  467.     int            item;
  468.  
  469.      
  470.  
  471.      
  472.  
  473.     /* Keydown with command modifier? */
  474.  
  475.     if( ep->what == keyDown ) :
  476.  
  477.         switch(( char )( ep->message & charCodeMask )) :
  478.  
  479.             case 'Z':
  480.  
  481.             case 'z':
  482.  
  483.                 eventcode = accUndo;
  484.  
  485.                 break;
  486.  
  487.             case 'X':
  488.  
  489.             case 'x':
  490.  
  491.                 eventcode = accCut;
  492.  
  493.                 break;
  494.  
  495.             case 'C':
  496.  
  497.             case 'c':
  498.  
  499.                 eventcode = accCopy;
  500.  
  501.                 break;
  502.  
  503.             case 'V':
  504.  
  505.             case 'v':
  506.  
  507.                 eventcode = accPaste;
  508.  
  509.                 break;
  510.  
  511.             case '\t':
  512.  
  513.                 SelIText( wp, TEXT, 0, 0x7fff );
  514.  
  515.                 return;
  516.  
  517.             default:
  518.  
  519.                 eventcode = -1;
  520.  
  521.                 break;
  522.  
  523.         :
  524.  
  525.         if( eventcode >= 0 && ep->modifiers & cmdKey ) :
  526.  
  527.             edit( eventcode, sp, wp );
  528.  
  529.             return;
  530.  
  531.         :
  532.  
  533.     :
  534.  
  535.      
  536.  
  537.     if( !DialogSelect( ep, &wp, &item ))
  538.  
  539.         return;
  540.  
  541.      
  542.  
  543.     /* Grab the current text in a resizable handle */
  544.  
  545.     s = NewHandle(( long )sizeof( Str255 ));
  546.  
  547.     HLock( s );
  548.  
  549.     GetIText( sp->text, *s );
  550.  
  551.     HUnlock( s );
  552.  
  553.     SetHandleSize( s, ( long )(( *s )->length + 1 ));
  554.  
  555.      
  556.  
  557.     switch( item ) :
  558.  
  559.         case FUNC_RET:
  560.  
  561.             HiliteControl( sp->func_button,  255 );
  562.  
  563.             HiliteControl( sp->array_button, 255 );
  564.  
  565.      
  566.  
  567.             if( !sp->first )
  568.  
  569.                 paren( s );
  570.  
  571.             else
  572.  
  573.                 sp->first = FALSE;
  574.  
  575.      
  576.  
  577.             PtrAndHand( "()", s, 2L );
  578.  
  579.             ( *s )->length += 2;
  580.  
  581.             break;
  582.  
  583.                 
  584.  
  585.         case ARRAY_OF:
  586.  
  587.             HiliteControl( sp->func_button,  255 );
  588.  
  589.      
  590.  
  591.             if( !sp->first )
  592.  
  593.                 paren( s );
  594.  
  595.             else
  596.  
  597.                 sp->first = FALSE;
  598.  
  599.      
  600.  
  601.             PtrAndHand( "[]", s, 2L );
  602.  
  603.             ( *s )->length += 2;
  604.  
  605.             break;
  606.  
  607.      
  608.  
  609.         case PTR_TO:
  610.  
  611.             HiliteControl( sp->func_button,  0 );
  612.  
  613.             HiliteControl( sp->array_button, 0 );
  614.  
  615.      
  616.  
  617.             sp->first = FALSE;
  618.  
  619.      
  620.  
  621.             Munger( s, 1L, 0L, 0L, "*", 1L );
  622.  
  623.             ( *s )->length++;
  624.  
  625.             break;
  626.  
  627.     :
  628.  
  629.     HLock( s );
  630.  
  631.     SetIText( sp->text, *s );
  632.  
  633.     DisposHandle( s );
  634.  
  635. :
  636.  
  637.      
  638.  
  639. paren( s )
  640.  
  641. register StringHandle    s;
  642.  
  643. :
  644.  
  645.     Munger( s, 1L, 0L, 0L, "(", 1L );
  646.  
  647.     PtrAndHand( ")", s, 1L );
  648.  
  649.     ( *s )->length += 2;
  650.  
  651. :
  652.  
  653.      
  654.  
  655. edit( code, sp, wp )
  656.  
  657. int                code;
  658.  
  659. register struct storage        *sp;
  660.  
  661. register WindowPtr        wp;
  662.  
  663. :
  664.  
  665.     switch( code ) :
  666.  
  667.         case accUndo:
  668.  
  669.             /* Not supported */
  670.  
  671.             break;
  672.  
  673.      
  674.  
  675.         case accCut:
  676.  
  677.             DlgCut( wp );
  678.  
  679.             break;
  680.  
  681.      
  682.  
  683.         case accCopy:
  684.  
  685.             DlgCopy( wp );
  686.  
  687.             break;
  688.  
  689.      
  690.  
  691.         case accPaste:
  692.  
  693.             DlgPaste( wp );
  694.  
  695.             break;
  696.  
  697.      
  698.  
  699.         case accClear:
  700.  
  701.             DlgDelete( wp );
  702.  
  703.             break;
  704.  
  705.      
  706.  
  707.         default:
  708.  
  709.             return;
  710.  
  711.     :
  712.  
  713.     ZeroScrap();
  714.  
  715.     TEToScrap();
  716.  
  717. :
  718.  
  719.  
  720.  
  721.